// 外部crate
extern crate redis;
//use redis::Commands;
//use redis::RedisResult;

// 自身Mod
use crate::infra;
use crate::services::HandlingServices;
//
use super::models;
pub struct Rhandler {
    // tx :tokio::sync::mpsc::Sender<usize>,
//rx : tokio::sync::mpsc::Receiver<usize>
}

impl Rhandler {
    // 初始化结构体
    pub fn new() -> Rhandler {
        //let x = tokio::sync::mpsc::channel::<usize>(16);
        Rhandler {}
    }
}
impl HandlingServices for Rhandler {
    // 取出数据执行核心算法MD5摘要算法存入List，
    // 通过闭包执行附加程序，
    // 此函数应该被rpc唤醒，但是我不想写了
    fn get_data_handling_storage(&self, _: String) {
        // 获取异步连接池redis执行者
        let redisexec = infra::mredis::RedisExec::new(&infra::mredis::REDISPOOL);
        // 获取一个同步连接
        //let client = match redis::Client::open("redis://127.0.0.1/1") {
        //     Ok(cli) => cli,
        //     Err(err) => panic!("HandlingServices 获取同步连接Client失败: {}", err),
        // };
        //let mut con = match client.get_connection() {
        //     Ok(con) => con,
        //     Err(err) => panic!("HandlingServices 获取同步连接失败: {}", err),
        // };
        //println!("redis list_name :{} 长度是 {}", list_name, list_len);
        // 实现状态机，根据获取的List长度循环执行
        //let len = list_len;
        //loop {
        // 获取链表长度
        // let list_len: i32 = redis::cmd("LLEN")
        //     .arg(&[list_name.as_str()])
        //     .query(&mut con)
        //     .unwrap();
        //     if list_len == 0 {
        //         break;
        //     }
        //     println!("获取长度是：{}",list_len);
        for _ in 0..10 {
            // if list_len == 0 {
            //     list_len = redis::cmd("LLEN")
            //         .arg(&["BufferList"])
            //         .query(&mut con)
            //         .unwrap();

            //     if list_len == 0 {

            //         break;
            //     }
            // }
            // list_len = list_len - 1;
            redisexec.get_list("BufferList".into(), move |result| {
                // 领域
                domain_func(result);
            });
        }
        //}
        //println!("跳出循环")
    }

    // 取出数据持久化到数据库,
    fn get_data_storage(&self) {}
}

// 领域层核心代码，
// 只关心得到的数据进行处理，
// result是数据库获得的结果
pub fn domain_func(result: String) {
    // 数据处理简约版
    use crypto_hash::{hex_digest, Algorithm};
    let chunk_id: i32 = result.split_at(20).1.parse().unwrap();
    let data = result.as_bytes();
    let hex: String = hex_digest(Algorithm::SHA256, data);
    //let hex:String = String::from("19980513");
    let info: String = String::from("XXXXXX");
    let nodeid: String = String::from("chain-henan-zhengzhou-jinshui-dongfeng-05");
    storage_data(models::spawn_hexinfo(hex, info, nodeid, chunk_id));
}
// 数据存储函数
fn storage_data(value: models::HexInfo) {
    use infra::mpsql::{PsqlExec, PSQLPOOL};
    let con = &PSQLPOOL.clone();
    let exec = PsqlExec::new(con);
    exec.inster_hexinfo(value.hex, value.info, value.nodeid, value.chunkid);
}

// 存入另一个链表
